home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Amiga Plus 1995 #5 & #6
/
Amiga Plus CD - 1995 - No. 5 and 6.iso
/
pd
/
serien
/
purity
/
nr.5
/
pascal
/
pcq-programme
/
game
/
game.mod
< prev
next >
Wrap
Text File
|
1995-04-19
|
16KB
|
438 lines
External;
{ Die hier folgenden Routinen sind alle für die Benutzung
ind den Spielen gedacht.
Nähere Informationen: siehe Dokumentation
}
CONST
CopyRight : string = "19. Juni 1992 , Jörg Wach ";
RevNummer : string = "Version V1.00";
{ --------------------------------------------------------------------- }
{ --------- GraphCollision ---------------------------------------- }
{ --------------------------------------------------------------------- }
{$I "include:Exec/libraries.i" }
{$I "include:exec/interrupts.i" } { für Permit/Forbid }
{$I "include:intuition/intuition.i"}
{$I "include:graphics/Pens.i" }
{$I "include:graphics/Text.i" }
{$I "include:graphics/Graphics.i" }
{$I "include:graphics/rastport.i" } { für den Rastport }
{$I "include:graphics/blitter.i" } { für die Blitter-Funktionen }
{ - Die verwendeten Typen, Constanten und Variablen. ------------------ }
TYPE
ObjektDef = record { die Definition meiner Spielobjekte }
Ox : short; { x-Position linke obere Ecke }
Oy : short; { y-Position linke obere Ecke }
Sizex : short; { x-size }
Sizey : short; { y-size }
Speedx : short; { x-Geschwindigkeit }
Speedy : short; { y-Geschwindigkeit }
Phase1 : short; { Bewegungsphasenzähler1 }
Phase2 : short; { Bewegungsphasenzähler2 }
typ : short; { Objekttyp }
end;
CONST
Objektsize : integer = sizeof(ObjektDef); { Größe eines Objektes }
VAR
Objekt : array[0..255] of ObjektDef; { Max. Anzahl der Objekte }
Picture : array[1..20] of Image; { Max. 20 Bilder }
blitctrl : short; { Globale Variable für Blitterergebnis }
BlittiSpeicher : Address; { Wird benötigt, weil überschneidungen
bei der Bearbeitung auftreten !!! }
MyBitMap : Address; { Adresse der BitMap }
MyRPort : RastPortPtr;
{ --------------------------------------------------------------------- }
Procedure GraphCollision( x1, y1, xsize, ysize : short);
{ Testet einen BitMapBereich auf vorhandene Punkte. xsize und ysize
bestimmen das Ausmaß des zu testenden Bereiches. }
var
dummy : integer; { Rückgabewert von BltBitMap. Wird nicht benötigt }
begin
Forbid(); { Taskswitching aus, damit ist der Blitter mein }
WaitBlit(); { Auf den Blitter warten, falls dieser noch arbeitet }
dummy := BltBitMap(MyBitMap,x1,y1,MyBitMap,x1,y1,xsize,ysize,$c0,1,BlittiSpeicher);
WaitBlit(); { Auf den Blitter warten, falls dieser noch arbeitet }
{$A
btst.b #5,$dff002 ; Diese Bit wollen wir testen
beq.s Collision1 ; Kollision
move.w #0,_blitctrl ; keine Kollision
bra.s Collision2 ; 2. BitPlane abfragen
Collision1:
move.w #1,_blitctrl ; Kollision. _blitctrl setzen
Collision2:
}
if blitctrl = 0 then begin { keine Kollision in der 1. Plane }
dummy := BltBitMap(MyBitMap,x1,y1,MyBitMap,x1,y1,xsize,ysize,$c0,2,BlittiSpeicher);
WaitBlit(); { Auf den Blitter warten, falls dieser noch arbeitet }
{$A
btst.b #5,$dff002 ; Diese Bit wollen wir testen
beq.s Collision3 ; Kollision
move.w #0,_blitctrl ; keine Kollision
bra.s Collision4 ; 3. BitPlane abfragen
Collision3:
move.w #1,_blitctrl ; Kollision
Collision4:
}
if blitctrl = 0 then begin { Keine Kollision in der 3. Plane }
dummy := BltBitMap(MyBitMap,x1,y1,MyBitMap,x1,y1,xsize,ysize,$c0,4,BlittiSpeicher);
WaitBlit(); { Auf den Blitter warten, falls dieser noch arbeitet }
{$A
btst.b #5,$dff002 ; Diese Bit wollen wir testen
beq.s Collision5 ; Kollision
move.w #0,_blitctrl ; keine Kollision
bra.s Collision6 ; Keine weitere BitPlane
Collision5:
move.w #1,_blitctrl ; Kollision
Collision6:
; Es gab keine Kollision
}
end; { Abfrage 3. Plane }
end; { Abfrage 2. Plane }
Permit(); { Andere wollen auch mal arbeiten ! }
end;{GraphCollision}
{ --------------------------------------------------------------------- }
{ --------- CollObjekt ---------------------------------------- }
{ --------------------------------------------------------------------- }
Function CollObjekt(von, bis, x1, y1, x2, y2 : short) : short;
{ Die Funktion ermittelt, welches Objekt in dem Rechteck x1, y1, x2, y2
Kollidiert ist. Hierbei kann ein von / bis Bereich für die Objekt-
untersuchung angegeben werden (0 - 255 ).
Wird als Von-Wert -1 angegeben, so werden alle Objekte untersucht und
die erste Objektnummer, die zur Kollision führte, zurück gegeben.
Ist der Rückgabewert -1, so gab es eine Kolision mit einem nicht
definierten Objekt bzw. das Objekt wurde nicht gefunden.
}
begin
{$A
movem.l d1-d7/a0-a3,-(sp) ; alle benutzten Register sichern
; Wahnsinn, 11 Stück !!!
; Die Parameter liegen deshalb auch
; an der um +44 Korrigierten SP-Adresse
lea _Objekt,a0 ; 1. Adresse der Elemente laden
move.l _Objektsize,a1 ; Größe der Objekte laden
move.w 56(sp),d1 ; bis (Urspünglich: 12(sp))
move.w 58(sp),d2 ; von (Urspünglich: 14(sp))
cmp.w #0,d2 ; sollen alle Objekte untersucht werden ?
beq.s CollObjekt2A ; Sonderfall !!! Objekt ist 0
bmi.s CollObjekt2 ; Dann müssen alle Objekte bearbeitet werden
movea.w d2,a3 ; sichern für den Rückgabezähler
sub.w d2,d1 ; Anzahl der Objekte - 1 (für dbra)
CollObjekt1:
adda.l a1,a0 ; Basisadresse + Objektgröße
subq #1,d2 ; d2 erniedrigen
bne.s CollObjekt1 ; Tatsächliche Adresse noch nicht ermittelt
bra.s CollObjekt3 ; Steht jetzt in a0
CollObjekt2:
move.w #255,d1 ; 256 Objekte sind zu bearbeiten
move.w #0,a3 ; 1. zu bearbeitende Objektnummer
bra.s CollObjekt3 ; weiter gehts
CollObjekt2A:
move.w #0,d1 ; 1 Objekt ist zu bearbeiten
move.w #0,a3 ; 1. zu bearbeitende Objektnummer
CollObjekt3:
; a0 = Startadresse des 1. Objektes
; a1 = Größe des Objektes
; a3 = Nummer des ersten Objektes
; d1 = Anzahl der Objekte -1
move.w 48(sp),d4 ; y2 (Urspünglich: 4(sp))
move.w 50(sp),d5 ; x2 (Urspünglich: 6(sp))
move.w 52(sp),d6 ; y1 (Urspünglich: 8(sp))
move.w 54(sp),d7 ; x1 (Urspünglich: 10(sp))
CollObjektLoop:
; Ab hier beginnt die Fragerei immer wieder
move.w (a0),d2 ; Ox1-Position in D2
bmi CollObjektNext ; zur Beschleunigung der Abfrage, da Objekt
; tot ist.
move.w 2(a0),d3 ; Oy1-Position in D3
cmp.w d7,d2 ; Ox1 >= Tx1
bge.s CollObjekt4 ; Ja
bra.s CollObjekt10 ; nein
CollObjekt4:
cmp.w d5,d2 ; Ox1 <= Tx2
bls.s CollObjekt100 ; Ja
; nein, weiter bei Stufe 10
CollObjekt10:
add.w 4(a0),d2 ; Ox1 um den x-size Wert erhöhen, um Ox2 zu bekommen
cmp.w d7,d2 ; Ox2 >= Tx1
bge.s CollObjekt11 ; Ja
bra.s CollObjekt20 ; nein
CollObjekt11:
cmp.w d5,d2 ; Ox2 <= Tx2
bls.s CollObjekt100 ; Ja
; nein, weiter bei Stufe 20
CollObjekt20:
move.w (a0),d2 ; Ox1 wieder auf den alten Wert bringen
cmp.w d2,d7 ; Tx1 >= Ox1
bge.s CollObjekt21 ; Ja
bra.s CollObjekt30 ; nein
CollObjekt21:
add.w 4(a0),d2 ; Ox1 um den x-size Wert erhöhen, um Ox2 zu bekommen
cmp.w d2,d7 ; Tx1 <= Ox2
bls.s CollObjekt100 ; Ja
; nein, weiter bei Stufe 30
CollObjekt30:
move.w (a0),d2 ; Ox1 wieder auf den alten Wert bringen
cmp.w d2,d5 ; Tx2 >= Ox1
bge.s CollObjekt31 ; Ja
bra CollObjektNext ; nein, also kein Treffer
CollObjekt31:
add.w 4(a0),d2 ; Ox1 um den x-size Wert erhöhen, um Ox2 zu bekommen
cmp.w d2,d5 ; Tx1 <= Ox2
bls.s CollObjekt100 ; Ja
bra CollObjektNext ; nein, also kein Treffer
CollObjekt100:
cmp.w d6,d3 ; Oy1 >= Ty1
bge.s CollObjekt101 ; Ja
bra.s CollObjekt110 ; nein
CollObjekt101:
cmp.w d4,d3 ; Oy1 <= Ty2
bls.s CollObjekt200 ; Ja
; nein, weiter bei Stufe 110
CollObjekt110:
add.w 6(a0),d3 ; Oy1 um den y-size Wert erhöhen, um Oy2 zu bekommen
cmp.w d6,d3 ; Oy2 >= Ty1
bge.s CollObjekt111 ; Ja
bra.s CollObjekt120 ; nein
CollObjekt111:
cmp.w d4,d3 ; Oy2 <= Ty2
bls.s CollObjekt200 ; Ja
; nein, weiter bei Stufe 120
CollObjekt120:
move.w 2(a0),d3 ; Oy1 wieder auf den alten Wert bringen
cmp.w d3,d6 ; Ty1 >= Oy1
bge.s CollObjekt121 ; Ja
bra.s CollObjekt130 ; nein
CollObjekt121:
add.w 6(a0),d3 ; Oy1 um den y-size Wert erhöhen, um Oy2 zu bekommen
cmp.w d3,d6 ; Ty1 <= Oy2
bls.s CollObjekt200 ; Ja
; nein, weiter bei Stufe 130
CollObjekt130:
move.w 2(a0),d3 ; Oy1 wieder auf den alten Wert bringen
cmp.w d3,d4 ; Ty2 >= Oy1
bge.s CollObjekt131 ; Ja
bra.s CollObjektNext ; nein, also kein Treffer
CollObjekt131:
add.w 6(a0),d3 ; Oy1 um den y-size Wert erhöhen, um Oy2 zu bekommen
cmp.w d3,d4 ; Tx1 <= Ox2
bls.s CollObjekt200 ; Ja
bra.s CollObjektNext ; nein, also kein Treffer
CollObjekt200:
; Alle Bedingungen sind erfüllt worden,
; also ein Treffer
move.w a3,d0 ; die getroffene Objektnummer in d0
bra.s CollObjektEnd ; und ab dafür
CollObjektNext:
; Eine oder mehrere Bedingungen wurden nicht
; erfüllt. Also das nächste Objekt.
adda.l a1,a0 ; Nächste Objektadresse
adda.w #1,a3 ; Objektnummer um eins erhöhen
dbra.s d1,CollObjektLoop ; und weiter geht's
moveq #-1,d0 ; wir haben kein passendes Objekt gefunden,
; also Fehler
CollObjektEnd:
movem.l (sp)+,d1-d7/a0-a3 ; alle benutzten Register wieder zurück
}
end;
{ --------------------------------------------------------------------- }
{ --------- DrawObjekt/ UnDrawObjekt ---------------------------- }
{ --------------------------------------------------------------------- }
Procedure DrawObjekt( VonNr, BisNr : short; MyPlanes, NotMyPlanes : byte );
{ Zeichnet die mit VonNr bis BisNr gekennzeichnete Objekte unter
Beachtung der vorgegebenen Masken }
var
tt1 : short;
begin
repeat
tt1 := Objekt[VonNr].Typ; { Welches Bild sollen wir zeichnen ? }
Picture[tt1].PlanePick := MyPlanes;
Picture[tt1].PlaneOnOff := NotMyPlanes;
DrawImage(MyRPort,ADR(Picture[tt1]),Objekt[VonNr].Ox,Objekt[VonNr].Oy);
INC(VonNr);
until VonNr > BisNr;
end; { DrawObjekt }
Procedure UnDrawObjekt( VonNr, BisNr : short );
{ Löscht die mit VonNr bis BisNr gekennzeichnete Objekte. }
var
tt1 : short;
begin
repeat
tt1 := Objekt[VonNr].Typ; { Welches Bild sollen wir zeichnen ? }
Picture[tt1].PlanePick := 0;
Picture[tt1].PlaneOnOff := 0;
DrawImage(MyRPort,ADR(Picture[tt1]),Objekt[VonNr].Ox,Objekt[VonNr].Oy);
INC(VonNr);
until VonNr > BisNr;
end; { UnDrawObjekt }
{ --------------------------------------------------------------------- }
{ --------- GetChar ---------------------------- }
{ --------------------------------------------------------------------- }
Function GetChar() : byte;
{ Liefert den RAW-Wert einer Taste zurück.
Ein paar Tastencodes: AMIGA-links : $33
AMIGA-rechts : $31
DEL : $73
Cursor hoch : 103
Cursor runter : 101
Cursor rechts : 99
Cursor links : 97
}
begin
{$A
move.b $bfec01,d0 ; Tastaturcode in D0
}
end; {GetChar}
{ --------------------------------------------------------------------- }
{ --------- GetJoy2 ---------------------------- }
{ --------------------------------------------------------------------- }
Function GetJoy2(): byte;
{ Gibt folgende Werte zurück:
0 - Joystick wurde nicht berührt
1 - Joystick nach rechts
2 - Joystick nach links
4 - Joystick nach hinten
8 - Joystick nach vorne
16 - Feuertaste gedrückt
}
begin
{$A
movem.l d1-d2,-(sp) ; Register sichern
moveq #0,d0 ; sauber machen
moveq #0,d1 ; sauber machen
move.w $DFF00C,d1 ; JOY1DAT holen
btst.l #1,d1 ; rechts ?
beq.s GetJoy201 ; nein
bset.l #0,d0 ; D0 setzen
GetJoy201:
btst.l #9,d1 ; links ?
beq.s GetJoy202 ; nein
bset.l #1,d0 ; D0 setzen
GetJoy202:
move.w d1,d2
lsr.w #1,d2
eor.w d1,d2
btst #0,d2 ; hinten ?
beq.s GetJoy203 ; nein
bset.l #2,d0 ; D0 setzen
GetJoy203:
btst #8,d2 ; vorne ?
beq.s GetJoy204 ; nein
bset.l #3,d0 ; D0 setzen
GetJoy204:
move.b $BFE001,d1 ; CIA-A, Paralellport a
btst.l #7,d1 ; Feuer ?
bne.s GetJoy205 ; nein
bset.l #4,d0 ; D0 setzen
GetJoy205:
movem.l (sp)+,d1-d2 ; Register zurück
}
end; { GetJoy2 }
{ --------------------------------------------------------------------- }
{ --------- ChipCopy ---------------------------- }
{ --------------------------------------------------------------------- }
Function ChipCopy( Source : Address; Size : integer) : Address;
{ Allokiert ChipMem in der Größe Size und kopiert die Daten von
der Addresse Source dort hinein. Zurückgegeben wird die ChipMem
Adresse.
}
begin
{$A
XREF _GfxBase
XREF _LVOAllocRaster
movem.l d1-d7/a0-a6,-(sp) ; register sichern
moveq #8,d0 ; 1 Byte mal
move.l 60(sp),d1 ; Size; ursprünglich: 4(sp)
move.l _GfxBase,a6
jsr _LVOAllocRaster(a6) ; anfordern
; d0 enthält jetzt die Adresse
tst.l d0 ; d0 testen
bne.s ChipCopy1 ; ist nicht Null, also alles O.K.
moveq #-1,d0 ; Returncode ist negativ
movem.l (sp)+,d1-d7/a0-a6 ; Register wieder zurück
rts ; und vorzeitiger Abbruch
ChipCopy1:
move.l 60(sp),d1 ; Size, ursprünglich: 4(sp), in d1
subq #1,d1 ; um eins korrigieren
move.l 64(sp),a0 ; Source, ursprünglich: 8(sp), in a0
move.l d0,a1 ; Destination in a1
Chipcopyloop:
move.b (a0)+,(a1)+ ; kopieren und um eins erhöhen
dbra.s d1,Chipcopyloop ; wenn noch nicht zuende, dann weitermachen
movem.l (sp)+,d1-d7/a0-a6 ; Register wieder zurück
; D0 enthält jetzt die ChipMemAdresse
}
end;{ ChipCopy }